package com.lizy.service.impl;

import com.lizy.mapper.RolePermissionMapper;
import com.lizy.mapper.UserRoleMapper;
import com.lizy.mapper.UsersMapper;
import com.lizy.pojo.Roles;
import com.lizy.pojo.UserRole;
import com.lizy.pojo.Users;
import com.lizy.pojo.vo.UserVo;
import com.lizy.service.UsersService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author 19688
 * @description 针对表【users】的数据库操作Service实现
 * @createDate 2024-09-02 22:33:24
 */
@Service
@Transactional
public class UsersServiceImpl extends ServiceImpl<UsersMapper, Users> implements UsersService {

    @Autowired
    UsersMapper userMapper;
    @Autowired
    RolePermissionMapper rolePermissionMapper;
    @Autowired
    UserRoleMapper userRoleMapper;

    /**
     * 插入用户信息
     * <p>
     * 该方法不仅将用户信息插入到用户表中，还会根据用户的角色ID更新用户角色关系表
     * 首先，它调用用户映射器的插入方法将用户对象插入到数据存储中然后，它从用户对象中检索角色ID
     * 创建一个新的用户角色对象，并设置用户ID和角色ID最后，调用用户角色映射器的插入方法来更新用户角色关系表
     *
     * @param user 要插入的用户对象，包含用户的所有必要信息
     */
    @Override
    public void insertUser(Users user) {
        // 将用户对象插入到数据存储中
        int i = userMapper.insert(user);
        // 检索用户的角色ID
        Integer roleId = user.getRoleId();
        // 创建一个新的用户角色对象
        UserRole userRole = new UserRole();
        // 设置用户ID
        userRole.setUserId(user.getUserId());
        // 设置角色ID
        userRole.setRoleId(roleId);
        // 更新用户角色关系表
        userRoleMapper.insert(userRole);
    }


    /**
     * 删除用户
     * <p>
     * 该方法不仅删除指定的用户，还会删除与该用户相关的所有用户角色关联
     * 使用了级联删除的概念，首先查询特定用户的所有角色，然后逐个删除这些角色关联，
     * 最后删除用户本身这是处理具有关联关系的数据的一种方式，确保数据一致性和完整性
     *
     * @param userId 用户ID，标识需要删除的用户
     */
    @Override
    public void deleteUser(Integer userId) {

        // 查询指定用户的所有用户角色关联
        QueryWrapper<UserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(UserRole::getUserId, userId);
        List<UserRole> userRoles = userRoleMapper.selectList(wrapper);

        // 遍历所有用户角色关联，并删除用户角色关联的一步
        userRoles.stream().forEach(roleId -> {
            userRoleMapper.deleteByUserId(roleId.getUserId());
        });

                //        for (UserRole userRole : userRoles) {
                //            userRoleMapper.deleteByUserId(userRole.getUserId());
                //        }

                        // 删除用户本身完成删除用户操作的最后一步
        userMapper.deleteById(userId);
    }


    /**
     * 更新用户信息
     * 此方法主要负责更新用户的角色信息，首先删除用户现有的所有角色，然后为用户分配新的角色
     * @param user 要更新的用户对象，包含用户ID和关联的角色ID
     *  good good study day day up
     *             you di da di da mi I hua la hua la you
     *             xi wang xia ci shen mo dou gang gang hao
     *
     */
    @Override
    public void updateUser(Users user) {
        // 创建查询包装器，用于查找与用户ID关联的所有角色
        QueryWrapper<UserRole> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(UserRole::getUserId, user.getUserId());
        // 获取用户现有的所有角色
        List<UserRole> userRoles = userRoleMapper.selectList(wrapper);
        // 删除用户现有的所有角色
        userRoles.stream().forEach(roleId -> {
            userRoleMapper.deleteByUserId(roleId.getUserId());
        });

        // 获取用户的新角色列表
        List<Roles> roles = user.getRoles();
        // 为用户分配新的角色
        roles.stream().forEach(role -> {
            UserRole userRole = new UserRole();
            userRole.setUserId(user.getUserId());
            userRole.setRoleId(role.getRoleId());
            userRoleMapper.insert(userRole);
        });
    }

    @Override
    public void updateByUser(UserVo userVo) {
        //删除用户和角色关联的表
        userRoleMapper.deleteByUserId(userVo.getUsers().getUserId());
        //修改用户表的信息
        Users users = userVo.getUsers();
        int i = userMapper.updateById(users);
        //修改完用户的信息循环遍历到角色与用户的中间表

    }
}







